package com.ease.common.util;

import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;

/**
 * 
 * @author nathanleewei
 * 
 */
public class NumericalUtil extends Detect {

	/**
	 * 将byte数组转化为十六进制的字符串
	 * 
	 * @param bytes
	 *            待转换的byte数组
	 * @return 十六进制字符串
	 */
	public static String byte2HexString(byte[] bytes) {
		String hs = "";
		String stmp = "";
		for (int n = 0; n < bytes.length; n++) {
			stmp = (java.lang.Integer.toHexString(bytes[n] & 0XFF));
			if (stmp.length() == 1)
				hs = hs + "0" + stmp;
			else
				hs = hs + stmp;
		}
		return hs.toUpperCase();
	}

	/**
	 * 将十六进制字符串转化为byte数组
	 * 
	 * @param hex
	 *            待转换的十六进制字符串
	 * @return byte数组
	 */
	public static byte[] hexString2Byte(String hex) {
		byte[] b = hex.getBytes();
		if ((b.length % 2) != 0)
			throw new IllegalArgumentException("长度不是偶数");
		byte[] b2 = new byte[b.length / 2];
		for (int n = 0; n < b.length; n += 2) {
			String item = new String(b, n, 2);
			b2[n / 2] = (byte) Integer.parseInt(item, 16);
		}
		return b2;
	}

	/**
	 * 将十六进制字符串转化为byte数组
	 * 
	 * @param b
	 *            待转换的字节数组
	 * @return byte数组
	 */
	public static byte[] hexString2Byte(byte[] b) {
		if ((b.length % 2) != 0)
			throw new IllegalArgumentException("长度不是偶数");
		byte[] b2 = new byte[b.length / 2];
		for (int n = 0; n < b.length; n += 2) {
			String item = new String(b, n, 2);
			int tempi = Integer.parseInt(item.toUpperCase(), 16);
			b2[n / 2] = (byte) tempi;
		}
		return b2;
	}

	/**
	 * 将byte转换为字符串,UTF8变码。
	 * 
	 * @param bytes
	 *            待转化的byte数组
	 * @return UFT编码的字符串
	 * @throws UnsupportedEncodingException
	 */
	public static String byte2String(byte[] bytes) throws UnsupportedEncodingException {
		return new String(bytes, "UTF-8");
	}

	/**
	 * 将长整型数转换成字节数组(n字节,低位在前)。
	 * 
	 * @param l
	 *            假定不为负
	 * @param n
	 *            字节数组的大小
	 * @return 如果n太小,则抛弃l的高位
	 */
	public static byte[] longToBytes(long l, int n) {
		byte[] result = new byte[n];
		for (int i = 0; i < n; i++) {
			result[i] = (byte) (l & 0xFF);
			l >>>= 8;
		}
		return result;
	}

	/**
	 * 将长整型数转换成字节数组(8字节,低位在前)。
	 * 
	 * @param l
	 *            假定不为负
	 * @return
	 */
	public static byte[] longTo8Bytes(long l) {
		return longToBytes(l, 8);
	}

	/**
	 * 将长整型数转换成字节数组(4字节,低位在前)。
	 * 
	 * @param l
	 *            假定不为负
	 * @return
	 */
	public static byte[] longTo4Bytes(long l) {
		return longToBytes(l, 4);
	}

	/**
	 * 将字节数组转化为long型
	 * 
	 * @param b
	 *            带状换字节数组,最大长度为8
	 * @param n
	 *            数组的位数
	 * @return
	 */
	public static long bytesToLong(byte[] b) {
		long temp = 0;
		long result = 0;
		for (int i = b.length - 1; i >= 0; i--) {
			temp = (long) b[i] & 0xFF;
			result <<= 8;
			result = result + temp;
		}
		return result;
	}

	/**
	 * 
	 * 保留两位小数
	 * 
	 * @param float
	 * @return float
	 */

	public static float floatRound(float f) {
		java.text.DecimalFormat myformat = new java.text.DecimalFormat("#0.00");
		return Float.parseFloat(myformat.format(f));
	}

	public static float floatRound(String a, String b, int i) {
		return new BigDecimal(a).divide(new BigDecimal(b), 2, BigDecimal.ROUND_HALF_UP).floatValue();
	}

}
